//=============================================================================
//                                                                            
//                               OpenMesh                                     
//      Copyright (C) 2001-2005 by Computer Graphics Group, RWTH Aachen       
//                           www.openmesh.org                                 
//                                                                            
//-----------------------------------------------------------------------------
//                                                                            
//                                License                                     
//                                                                            
//   This library is free software; you can redistribute it and/or modify it 
//   under the terms of the GNU Library General Public License as published  
//   by the Free Software Foundation, version 2.                             
//                                                                             
//   This library is distributed in the hope that it will be useful, but       
//   WITHOUT ANY WARRANTY; without even the implied warranty of                
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         
//   Library General Public License for more details.                          
//                                                                            
//   You should have received a copy of the GNU Library General Public         
//   License along with this library; if not, write to the Free Software       
//   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 
//                                                                            
//-----------------------------------------------------------------------------
//                                                                            
//   $Revision: 1.3 $
//   $Date: 2005-12-21 13:58:54 $
//                                                                            
//=============================================================================

/** \file LaplaceSmootherT.cc

*/

//=============================================================================
//
//  CLASS LaplaceSmootherT - IMPLEMENTATION
//
//=============================================================================

#define OPENMESH_LAPLACE_SMOOTHERT_C

//== INCLUDES =================================================================

#include <Tools/Smoother/LaplaceSmootherT.hh>


//== NAMESPACES ===============================================================


namespace OpenMesh {
	namespace Smoother {


		//== IMPLEMENTATION ========================================================== 


		template <class Mesh>
		LaplaceSmootherT<Mesh>::
			LaplaceSmootherT(Mesh& _mesh)
			: SmootherT<Mesh>(_mesh)
		{
			// custom properties
			Base::mesh_.add_property(vertex_weights_);
			Base::mesh_.add_property(edge_weights_);
		}


		//-----------------------------------------------------------------------------


		template <class Mesh>
		LaplaceSmootherT<Mesh>::
			~LaplaceSmootherT()
		{
			// free custom properties
			Base::mesh_.remove_property(vertex_weights_);
			Base::mesh_.remove_property(edge_weights_);
		}


		//-----------------------------------------------------------------------------


		template <class Mesh>
		void
			LaplaceSmootherT<Mesh>::
			initialize(Component _comp, Continuity _cont)
		{
			SmootherT<Mesh>::initialize(_comp, _cont);

			// calculate weights
			switch (_comp)
			{
			case Base::Tangential:
				compute_weights(UniformWeighting);
				break;


			case Base::Normal:
				compute_weights(CotWeighting);
				break;


			case Base::Tangential_and_Normal:
				compute_weights(UniformWeighting);
				break;
			}
		}


		//-----------------------------------------------------------------------------


		template <class Mesh>
		void
			LaplaceSmootherT<Mesh>::
			compute_weights(LaplaceWeighting _weighting)
		{
			typename Mesh::VertexIter        v_it, v_end(Base::mesh_.vertices_end());
			typename Mesh::EdgeIter          e_it, e_end(Base::mesh_.edges_end());
			typename Mesh::HalfedgeHandle    heh0, heh1, heh2;
			typename Mesh::VertexHandle      v0, v1;
			const typename Mesh::Point       *p0, *p1, *p2;
			typename Mesh::Normal            d0, d1;
			typename Mesh::Scalar            weight, lb(-1.0), ub(1.0);



			// init vertex weights
			for (v_it=Base::mesh_.vertices_begin(); v_it!=v_end; ++v_it)
				Base::mesh_.property(vertex_weights_, v_it) = 0.0;



			switch (_weighting)
			{
				// Uniform weighting
			case UniformWeighting:
				{
					for (e_it=Base::mesh_.edges_begin(); e_it!=e_end; ++e_it)
					{
						heh0   = Base::mesh_.halfedge_handle(e_it.handle(), 0);
						heh1   = Base::mesh_.halfedge_handle(e_it.handle(), 1);
						v0     = Base::mesh_.to_vertex_handle(heh0);
						v1     = Base::mesh_.to_vertex_handle(heh1);

						Base::mesh_.property(edge_weights_, e_it) = 1.0;
						Base::mesh_.property(vertex_weights_, v0) += 1.0;
						Base::mesh_.property(vertex_weights_, v1) += 1.0;
					}

					break;
				}


				// Cotangent weighting
			case CotWeighting:
				{
					for (e_it=Base::mesh_.edges_begin(); e_it!=e_end; ++e_it)
					{
						weight = 0.0;

						heh0   = Base::mesh_.halfedge_handle(e_it.handle(), 0);
						v0     = Base::mesh_.to_vertex_handle(heh0);
						p0     = &Base::mesh_.point(v0);

						heh1   = Base::mesh_.halfedge_handle(e_it.handle(), 1);
						v1     = Base::mesh_.to_vertex_handle(heh1);
						p1     = &Base::mesh_.point(v1);

						heh2   = Base::mesh_.next_halfedge_handle(heh0);
						p2     = &Base::mesh_.point(Base::mesh_.to_vertex_handle(heh2));
						d0     = (*p0 - *p2); d0.normalize();
						d1     = (*p1 - *p2); d1.normalize();
						weight += 1.0f / tan(acos(std::max(lb, std::min(ub, dot(d0,d1) ))));

						heh2   = Base::mesh_.next_halfedge_handle(heh1);
						p2     = &Base::mesh_.point(Base::mesh_.to_vertex_handle(heh2));
						d0     = (*p0 - *p2); d0.normalize();
						d1     = (*p1 - *p2); d1.normalize();
						weight += 1.0f / tan(acos(std::max(lb, std::min(ub, dot(d0,d1) ))));

						Base::mesh_.property(edge_weights_, e_it) = weight;
						Base::mesh_.property(vertex_weights_, v0)  += weight;
						Base::mesh_.property(vertex_weights_, v1)  += weight;
					}
					break;
				}
			}


			// invert vertex weights:
			// before: sum of edge weights
			// after: one over sum of edge weights
			for (v_it=Base::mesh_.vertices_begin(); v_it!=v_end; ++v_it)
			{
				weight = Base::mesh_.property(vertex_weights_, v_it);
				if (weight)
					Base::mesh_.property(vertex_weights_, v_it) = 1.0f / weight;
			}
		}



		//=============================================================================
	} // namespace Smoother
} // namespace OpenMesh
//=============================================================================
